#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <pthread.h>

struct DannI
{
	double x1;
	double x2;
	double res_func;
	int pth_col;
} ;

double step;

double func (double x)
{
	double res;
	res = sqrt(fabs(x));
	return res;
}



void *summ (void *par)

{

struct DannI *param;

pthread_t left, right;

double tmp;
void *res1,*res2,*res;
struct DannI date1, date2;
double d_res,d_res1,d_res2,d_res3;
int return_value;
double x1, x2;
int i;
param=(struct DannI*) par;

x1=param->x1;
x2=param->x2;
printf("start(%g,%g)\n",x1,x2);
if (param->pth_col > 0) 
{
if ((x2-x1)>step)
{
	tmp = (x1+x2)/2;
	date1.x1=x1;
	date1.x2=tmp;
	date2.x1=tmp;
	date2.x2=x2;
	date1.pth_col=param->pth_col-1;
	date2.pth_col=param->pth_col-1;

	return_value =pthread_create (&left,NULL,summ, &date1);
          if ( return_value != 0 )
          {
            perror("Could not create thread");
            exit(2);
            left=0;
          }

	return_value =pthread_create (&right,NULL,summ,&date2);
          if ( return_value != 0 )
          {
            perror("Could not create thread");
            exit(2);
            right=0;
          }
	
	pthread_join (left,&res1);
	pthread_join (right,&res2);
	
	d_res1=date1.res_func;
	
	d_res2=date2.res_func;
	d_res=d_res1+d_res2;
	param->res_func=d_res;	
	
	return NULL;
}
else 
{
	tmp = (x1+x2)/2;
	
	d_res1 = func(tmp);
	d_res2 = d_res1*step;
	param->res_func=d_res2;	
	return NULL;	
}
}
else 
{	
	d_res1=param->x1;
	d_res2=param->x2;
	d_res=0;
	d_res3=d_res1;
	while ((d_res2 - d_res3) > ( step/2))
	{
		
		d_res3=d_res1+step;
		tmp = (d_res1+d_res3)/2;
		d_res =d_res+ func(tmp)*step;
		d_res1=d_res3;

	}	
	
	param->res_func=d_res;	
	return NULL;	
}


}


int main (int argc, char* argv[])
{
  /*
 * Входными параметрами являются границы интервала, на котором нужно вычислить интеграл.
 * Также можно задать точность вычисления (шаг).
 * Вычисление проиходит в рекрсивно в потоках. Глубина рекурсии задается в коде и равна 4.
 */
 
pthread_t th;
double x1,x2;
int return_value;
void *res;
double ress;


struct DannI data;
if (argc <3) 
{
printf ("arguments  invalid \n");
exit(1);
}

if (argc >=4)
{
step = atof(argv[3]);
}
else step = 0.000001;
printf("start integral y=sqrt(abs(x)) \n");
x1=atof(argv[1]);
x2=atof(argv[2]);
data.pth_col=4;
if (x1>x2)
{
  data.x1=x2;
  data.x2=x1;
}
else 
{
  data.x1=x1;
  data.x2=x2;
}



	return_value = pthread_create (&th,NULL,summ, &data);
          if ( return_value != 0 )
          {
            perror("Could not create thread");
            exit(2);
            th=0;
          }

pthread_join (th,&res);
ress = data.res_func;
	
printf("result: %g \n",ress);
}
